home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / C / Frameworks / Hsoi's App Shell 1.0a4 / Hsoi's App Shell Source / HASUtilCursors.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-01-28  |  26.6 KB  |  679 lines  |  [TEXT/CWIE]
  1. /*
  2.     HASUtilCursors.c from Hsoi's App Shell. © 1995-1997 John C. Daub.  All rights reserved.
  3.     
  4.     This file contains various cursor related functions and utilities.
  5. */
  6.  
  7. #pragma mark ••• #includes •••
  8.  
  9. #ifndef _WASTE_
  10. #include "WASTE.h"
  11. #endif
  12. #include "HASGlobals.h"
  13. #ifndef __HSOIS_APP_SHELL__
  14. #include "HASMain.h"
  15. #endif
  16. #include "HASUtilCursors.h"
  17. #include "HASUtilDialogs.h"
  18. #include "HASUtilities.h"
  19. #include "HASSoundSpeech.h"
  20. #ifndef __QUICKDRAW__
  21. #include <QuickDraw.h>
  22. #endif
  23. #ifndef __RETRACE__
  24. #include <Retrace.h>
  25. #endif
  26. #ifndef __CURSORCTL__
  27. #include <CursorCtl.h>
  28. #endif
  29.  
  30.  
  31. #pragma mark -
  32. #pragma mark ••• Init Cursors •••
  33.  
  34. // HsoiSetUpCursors() is called at startup time to get our various cursors set up.
  35. // i like obtaining Handles to frequently used cursors now and using these globals
  36. // in SetCursor() instead of calling GetCursor() all the time (avoid accessing the
  37. // toolbox/rom's to save a little time).
  38.  
  39. void    HsoiSetUpCursors( void )
  40. {
  41.     // get our i-beam and static (not animated) watch cursors
  42.     
  43.     gEditCursor = GetCursor(iBeamCursor);
  44.     gWaitCursor = GetCursor(watchCursor);
  45.  
  46.     // move and lock them high in the application heap
  47.     
  48.     HLockHi( (Handle)gEditCursor );
  49.     HLockHi( (Handle)gWaitCursor );
  50.     
  51.     return;
  52. }
  53.  
  54.  
  55. #pragma mark -
  56. #pragma mark ••• Manual Spin Cursor •••
  57.  
  58. OSErr    HsoiStartManualSpinning( void )
  59. {
  60.     OSErr        err = noErr;
  61.     
  62.     // now get our animated wait cursor
  63.     
  64.     // get a handle to the 'acur' resource..
  65.     
  66.     gAnimWatchCursor = (acurHandle)GetResource( TYPE_ANIMATED_CURSOR, rSpinningWatchACUR );
  67.     
  68.     if ( gAnimWatchCursor == nil ) // didn't get it, probably not there or not enough memory to load it
  69.         HsoiDoError( rErrorStrings, errFailGetResource, ResError(), kErrDeath ); // death, i know..extreme
  70.         
  71.     // move it high in the heap so we don't fragment our memory
  72.  
  73.     MoveHHi( (Handle)gAnimWatchCursor );
  74.     err = ResError();
  75.     if ( err != noErr )
  76.     {
  77.         // if the handle is locked (i.e. we can't move it)
  78.         
  79.         if ( err == memLockedErr )
  80.         {
  81.             HUnlock( (Handle)gAnimWatchCursor );
  82.             MoveHHi( (Handle)gAnimWatchCursor );
  83.             HLock( (Handle)gAnimWatchCursor );
  84.             err = noErr;
  85.         }
  86.         else
  87.         {
  88.             HsoiDoError( rErrorStrings, errFailGetResource, err, kErrDeath );
  89.         }
  90.     }
  91.         
  92.     // initialize the rotation routines (glue for these, in CW, is in the
  93.     // ToolLibs.o).  (right now, this isn't a VBL task...i.e. if you want the
  94.     // cursor you spin, you'll have to do it all yourself.  see my sample
  95.     // movable modal dialog (the progress bar thing) for an example of this)
  96.     
  97.     // or, see later on in this file for how to do a VBL spinning cursor (i.e.
  98.     // you don't have to do it all yourself!)
  99.     
  100.     InitCursorCtl( gAnimWatchCursor );    
  101.  
  102.     SpinCursor( 0 );    // get our cursor ready to spin!
  103.  
  104.     return err;
  105. }
  106.  
  107. OSErr    HsoiStopManualSpinning( void )
  108. {
  109.     OSErr    err = noErr;
  110.  
  111.     // unlock the animated cursor resources
  112.     
  113.     HUnlock( (Handle)gAnimWatchCursor );
  114.     
  115.     // make sure it can be purged
  116.     
  117.     HPurge( (Handle)gAnimWatchCursor );
  118.     
  119.     // and dispose of it
  120.     
  121.     HsoiForgetResource( (Handle *)&gAnimWatchCursor );
  122.     
  123.     // set the cursor to the arrow
  124.     
  125.     InitCursor();
  126.         
  127.     
  128.     return err;
  129. }
  130.  
  131. #pragma mark -
  132. #pragma mark ••• Other Cursor Utils •••
  133.  
  134. // HsoiIBeamIt() would be called in a dialog filter so that it's called "constantly" to
  135. // track the movement of the cursor.  If the cursor moves over an active edit line, the
  136. // cursor is changed to an I-Beam cursor, else an arrow.
  137.  
  138. // this function is not necessary for HAS since we're under System 7 (at least), cause
  139. // system 7's dialog manager provides a routine (SetDialogTracksCursor()) to do this for us.
  140. // but, i'll leave the code in here just in case you want to know about this sort of thing
  141. // (cause tracking a cursor is something we all need to know how to do)
  142.  
  143. void    HsoiIBeamIt(WindowRef window)
  144. {
  145.     Point    mouseAt;
  146.     Rect    borderRect;
  147.     short    itemNum;
  148.     
  149.     // first get the current edit line out of the dialog record
  150.     
  151.     itemNum = GetDialogKeyboardFocusItem(window);
  152.     HsoiGetDialogItemRect( window, itemNum, &borderRect );
  153.     
  154.     // find where the mouse is at
  155.     
  156.     GetMouse(&mouseAt);
  157.     
  158.     // if it's within our dialog item, change to the i-beam else the arrow
  159.     
  160.     if (PtInRect(mouseAt, &borderRect))
  161.     {
  162.         SetCursor( *gEditCursor );
  163.  
  164.         // or, you could call it like this:
  165.         // SetCursor(*(GetCursor(1)));
  166.         // if you don't want dependance on the HAS globals
  167.         
  168.     }
  169.     else
  170.     {
  171.         // This means I'm callng InitCursor every time through my filter
  172.         // this is a little excessive (ha!) but doesn't hurt anything.
  173.         // You could set a global or something if this really offends you
  174.     
  175.         InitCursor();
  176.         
  177.     }
  178.     
  179.     return;
  180. } 
  181.  
  182.  
  183. // HsoiAdjustCursor() is called in the main event loop.  it finds where the
  184. // cursor is and then adjusts it's appearance based upon the mouse's location
  185. // on the screen
  186.  
  187. void    HsoiAdjustCursor( Point mouseLoc, RgnHandle mouseRgn )
  188. {
  189.     WindowRef    window;
  190.     
  191.     /*    by default, set mouseRgn to the whole QuickDraw corrdinate plane, */
  192.     /*    so that we never get mouse moved events */
  193.     
  194.     SetRectRgn( mouseRgn, -MAXSHORT, -MAXSHORT, MAXSHORT, MAXSHORT );
  195.  
  196. /*
  197.     the cursor is set to the watch cursor by DoMovableModalDialog(), and removed (set back
  198.     to the arrow or whatever) when DialogHit() is called or the movable modal dialog
  199.     is dismissed.  Futhermore, it is necessary to make sure that WEAdjustCursor() does
  200.     check if gPeriodicTask, cause otherwise it'll change it! 
  201. */    
  202.     if ( gPeriodicTask )
  203.         return;    
  204.  
  205.     /*    give text services a change to set the cursor shape */
  206.     
  207.     if ( gHasTextServices )
  208.     {
  209.         if ( SetTSMCursor( mouseLoc ) )
  210.             return;
  211.     }
  212.     
  213.     /*
  214.         if there is a window open, give WEAdjustCursor() an opportunity to set the cursor.
  215.         WEAdjustCursor() insersects mouseRgn (if supplied) with a region within which
  216.         the cursor is to regain its shape.  if the cursor is outside the view region,
  217.         this is subtracted from mouseRgn.
  218.         
  219.         and note, only call WEAdjustCursor if there is a window, the window is a
  220.         document window (at least needs a WASTE instance attached to it, but we
  221.         don't want the clipboard window to get an edit cursor else that might "tell" the
  222.         user they can edit the clipboard window), and there isn't a periodic task in
  223.         effect (but this is already taken care of above).
  224.     */
  225.     
  226.     window = FrontWindow();
  227.  
  228.     if ( (window != nil) && HsoiIsDocumentWindow( window ) )
  229.     {
  230.         if ( gHiliting )
  231.         {
  232.             InitCursor();
  233.             return;
  234.         }
  235.         
  236.         if ( WEAdjustCursor( mouseLoc, mouseRgn, HsoiGetWindowWE(window) ) )
  237.             return;
  238.     }
  239.  
  240.  
  241.     /*    if we made it this far, set the cursor to the arrow cursor */
  242.  
  243.     // don't use InitCursor() cause that'll make the cursor flicker cause InitCursor()
  244.     // shows the cursor (i think it calls ShowCursor()).  using SetCursor will set
  245.     // it properly to an arrow, but if it's hidden, it will remain hidden.
  246.         
  247.     SetCursor( &qd.arrow );
  248.     
  249.     return;
  250. }
  251.  
  252.  
  253. #pragma mark -
  254. #pragma mark ••• VBL Spinning Cursor •••
  255.  
  256. /*
  257.     what follows here is code related to spinning a cursor.  but this isn't any old
  258.     spin cursor stuff...it's spinning a cursor as a VBL Task!  Just what is a VBL
  259.     Task?  well first, VBL stands for Vertical Blanking Interrupt.  This is something
  260.     generated by the Vertical Retrace Manager, "the part of the Operating System
  261.     that schedules and executes recurrent tasks during vertical retrace interrupts.
  262.     You can use the Vertical Retrace Manager to execute simple, repetitve tasks and
  263.     avoid having to execute those tasks repeatedly in your application's main event
  264.     loop" (Inside Macintosh: Processes, 4-3).
  265.     
  266.     Here's the jist of how it works. (this is taken from Inside Macintosh: Processes,
  267.     4-4).
  268.     
  269.     The video circuitry in a Macintosh computer, whether built-in or external, refreshes
  270.     the screen at regular intervals.  For built-in monitors, the screen is refreshed
  271.     approximately 60 times per second; for external monitors, the screen is refreshed at
  272.     intervals determined by the associated video hardware.  To refresh the screen, the
  273.     monitor's electron beam draws one pixel at a time, starting at the upper-left corner
  274.     of the screen and moving quickly to the lower-right corner.  When the electron beam
  275.     returns from the lower-right corner of the screen to the upper-left corner, the video
  276.     circuitry generates a "vertical retrace interrupt" or "vertical blanking (VBL) interrupt".
  277.     
  278.     The Vertical Retrace Manager is the part of the Operating System that schedules and
  279.     executes tasks -- known as VBL tasks -- during a vertical retrace interrupt.  The
  280.     Operating System itself uses the Vertical Retrace Manager to perform some important
  281.     housekeeping operations, such as moving the cursor in response to mouse
  282.     movements and checking whether the current application's stack has expanded into it's
  283.     heap.  Within the limitations described in this chapter [Chapter 4 of IM:Processes],
  284.     you can use the VRMgr to install your own recurrent tasks [like the spinning cursor
  285.     we're about to do].
  286.     
  287.     In general, the VRMgr is useful for small, repetitive tasks that do not allocate or
  288.     release memory and that you do not want to execute in your main event loop.  Whenever
  289.     possible, it is best to manage periodic tasks within your main event loop [for
  290.     example, the sample movable modal dialog coupled with HsoiDoMainLoopTasks].  However,
  291.     if you want some task some task to execute repetitvely at a time when you do not want
  292.     to reenter your main event loop (perhaps because you don't want your application to
  293.     be switched out during some lengthy operation), it might be possible to use the VRMgr
  294.     to execute the task.
  295.     
  296.     The principal limitation on VBL tasks (aside from the limitations on any interrupt-time
  297.     processing) is that they cannot execute more frequently than once per VBL interrupt.
  298.     [the exact timing of a VBL interrupt will vary from monitor to monitor based upon
  299.     that monitor's refresh frequency.  If you need more exact timing and/or more often
  300.     execution than a VBL task would allow, use the Time Manager, explained in IM: Processes.
  301.     Additionally, the VRMgr is NOT an absolute timing mechanism...it's always relative
  302.     to VBL interrupts.  If absolute time delays are important, use the Time Manager.
  303.     VRMgr stuff is good in cases where the scheduled actions need simply to be synchronized
  304.     with other VBL tasks, such as moving the cursor or refreshing the screen].
  305.     
  306.     I don't want to include all of Chapter 4 of IM:Processes here (you can get this
  307.     at your local bookstore, or even off the Internet from Apple's ftp and web
  308.     sites...try http://dev.info.apple.com/).  But this should be sufficient to explain
  309.     just what the heck a VBL task is and how it works so you can understand what i'm
  310.     about to do.  And just as an fyi sorta thing, here are the VBL tasks installed
  311.     by the MacOS (from IM: Processes, 4-5):
  312.     
  313.         Every interrupt:
  314.             • update the value of the global variable "Ticks" which a program may access
  315.               throughout the routine TickCount()
  316.             • call the "stack sniffer" to see if the current application's stack and heap
  317.               have collided.  If so, the task calls the System Error Handler
  318.             • update the position of the cursor
  319.         
  320.         Every 30 interrupts
  321.             • Check whether the user has inserted a disk or a mounted a volume.  If so,
  322.               the task posts a disk-inserted event.
  323.         
  324.         Evert 32 interrupts
  325.             • Check whether a keyboard has been reattached after having been detached. If
  326.               so, the task resets the keyboard.
  327.     
  328.     incidentally, some VBL routines may execute only on certain computers or only in
  329.     certain versions of system software.  Also, VBL tasks installed by the OS are not
  330.     maintained in the same queue used for application-defined VBL tasks.
  331.     
  332.     So, that should be more than enough for you to start understanding VBL tasks and
  333.     this spinning cursor stuff I'm about to do.  If you'd like to read more about
  334.     this sort of thing  (and you should!), check out Inside Macintosh.  I do highly
  335.     recommend that you do read IM:Processes (all of it, it's pretty short) if you
  336.     want to do anything with VBL tasks...it's a pretty easy thing to use, but there
  337.     are lots of things to be careful about.  it's too much stuff to list here, so
  338.     getting your own copy of the book is best.
  339. */
  340.  
  341. /*
  342.     Now, some other notes :)
  343.     
  344.     There are all sorts of ways to spin the cursor.  I impliment a nice way of doing
  345.     this with my movable modal dialog progress bar thing (from the Dialogs menu,
  346.     select MovableModal Dialog).
  347.     
  348.     I've also seen lots of sample code that can do VBL tasks.  For example, in Scott
  349.     Knaster's book "Macintosh Programming Secrets" 2nd ed. Chapter 10, Knaster gives
  350.     us a wonderful VBL spinning cursor.  But there is a problem with Knaster's code.
  351.     It uses assembly language!  Now, this really isn't a problem, in fact it's
  352.     pretty cool.  However, I would prefer to not use any assembly in HAS.  why?
  353.     well, how many people out there know assembly? (if you don't, you should at least
  354.     get familiar with it for debugging and optimization purposes...but that's an
  355.     advanced thing...and fyi, 2 good books for learning this sort of thing, tho
  356.     a bit old and out of date, are the MacsBug Reference and Debugging Guide
  357.     (from Apple Computer.  as of this writing, it covers MacsBug 6.2 tho the latest
  358.     version of Macsbug is 6.5.2, so a little out of date, but still relevant) and
  359.     Scott Knaster's How to Write Macintosh Software (currently in it's 3rd edition
  360.     and desperately, IMHO, in need up and update since it's all in Pascal and
  361.     doesn't cover PowerMacs and assembly for PowerPC chips, only assembly
  362.     for 680x0 chips)).
  363.     
  364.     Also, the code in Knaster's MPS book is made for THINK C (not CodeWarrior).
  365.     so the changes would be problematic (actually, I'm just lazy).
  366.     
  367.     And also, this assembly probably won't work on PowerMacs! (dunno, haven't
  368.     tried it, but I remember something clicked in my mind knowing that the code
  369.     won't work...I think it's cause of the A5 register stuff and storing stuff
  370.     at A0).
  371.     
  372.     So, what I've got here is basically taken right out of IM:Processes (with
  373.     some appropriate and necessary modifications), and perhaps a bit of
  374.     Knaster-knowledge thrown in.
  375.     
  376.     Incidentally, tho Knaster's code probably can't work in this sort of situation
  377.     I'm going for, his explanations and stuff is still worth a million bucks.
  378.     I still say that if you have the money, get Knaster's book(s).
  379.     
  380.     OH!...one last thing.  right now I'm only implimenting this spinning cursor
  381.     in CreateWindow() when/if there is a file to read in. To test all this stuff,
  382.     i created a HUGE text file (i saved my Help stuff as a text file, then select
  383.     all, copy, paste...then select all again, copy paste...etc...did it over and
  384.     over...the file is about 842k (text, styl, soup, etc) all in all..takes some
  385.     time to open up needless to say!  Things seem to work ok.)
  386.     
  387.     Now, while i was creating this file, with all the pasting i was doing (and
  388.     as i progressed, the pastes got bigger and bigger) it was taking some substantial
  389.     time (at least substantial on my IIvx with it's 68030 @ 32mHz) to paste!
  390.     so, if you'd like to in your program (or your toying with HAS) you might want
  391.     to use this VBL code anytime you would need a wait cursor (pasting is definately
  392.     one place, there could be others...you decide).  One nice thing about this code
  393.     is that the spinning cursor isn't activated immediately...a couple seconds go
  394.     by before the spinning cursor happens.  this way, if the operation you're performing
  395.     takes a very short time (like less than a couple seconds) the "wait" cursor
  396.     never kicks in (tho the VBL task was installed).  then if the operation was
  397.     taking a long time, the spinning wait cursor happens...joys of VBL eh?  you'd
  398.     not really be able to determine such a thing normally...like i could determine
  399.     all this "manually" with something like my HsoiDoMainLoopTasks, but with
  400.     something like pasting (calling WEPaste), you'd have to patch WEPaste, that's
  401.     not recommended to do (else risk non-conformity with the WASTE API and you'd
  402.     have to "reinstall" your custom hacks to WASTE every time a new WASTE API was
  403.     released).
  404.     
  405.     so, this is a cool thing eh?
  406.     
  407.     but one thing to be wary about...if you had a spinning cursor then switched
  408.     your app into the background, you could have problems...(haven't tried this
  409.     myself yet, but i'm sure it'd be a problem).  be careful about this...
  410.     layer switching (i.e. suspend/resume events) with an application-specific-active
  411.     VBL task installed could leave the VBL task running and make for a confused
  412.     user.  right now we get around this by calling Start and Stop around and
  413.     in functions where we know a layer switch could never occur.  In this sort
  414.     of instance, i can think of 2 possible things to do:  1. create something
  415.     similar to the HsoiDoMainLoopTasks and my sample movable modal dialog.
  416.     that coupled with the rest of the event loop (and the rest of HAS's structuring)
  417.     makes things work ok.  2.  you could do something in your suspend/resume
  418.     event handling to check for your application's VBL tasks and remove/reinstall
  419.     them at suspend/resume time.  (actually, as long as you call these VBL
  420.     tasks around/in a function that doesn't bother with the main event loop (like
  421.     how i'm using it solely in HsoiCreateWindow), you're ok...if you want to
  422.     learn more about this sort of thing, IM:Processes covers all the details
  423.     you'd need to know about VBL's and application execution with major/minor
  424.     context switches, etc...again, another good reason to get IM:Processes)
  425.     
  426.     also, one thing I'm curious about....there are 2 general types of VBL tasks.
  427.     a system-based VBL task (where the OS maintains just one task queue and processes
  428.     the tasks in that queue when it receives a VBL interrupt and is not linked to
  429.     any external device, like a monitor).  This is what I am currently doing.
  430.     
  431.     however, one thing I've tried to do with HAS is demonstrate how to have code
  432.     that's happy in multiple monitor setups (like HsoiDoDrag()) since so few people
  433.     know how to do this and so few apps are happy with multiple monitors (something
  434.     you should strive for: an app happy regardless (pretty much) of the user's
  435.     computer setup).  There is another VBL task type: a slot-based VBL task.
  436.     this type of task is linked to an external video monitor.  because different
  437.     monitors can have different refresh rates and hence might execute VBL tasks
  438.     at different times, the VRMgr maintains a separate task queue for each video
  439.     device attached to the computer.  then when a vbl interrupt occurs for a
  440.     particular device, the VRMgr executes any tasks in the queue for the slot holding
  441.     that monitor's video card. (and you'd then install a slot-based VBL task via
  442.     SlotVInstall()).
  443.     
  444.     so, how might this code behave (and break?) in multiple monitor setups?  if
  445.     the cursor got moved onto another monitor while the task was executing, i'm
  446.     certain the redraws (remember, cool thing with VBL tasks is that the animation
  447.     would be synced with the screen refresh for nice animation) would fall
  448.     differently (different monitors, different refresh rates) and cause funky
  449.     drawing of the cursor...i hypothesize that the VBL task would still occur
  450.     (just based upon the system VBL queue), but just (re)draw all funky, y'know?
  451.     
  452.     but then, it's hard for me to test and figure this out since i only have
  453.     a single monitor at home :(
  454.     
  455.     I'd think what you'd want to do would be in the Start function, instead
  456.     of just calling VInstall, you'd step through the device list and for
  457.     each device call SlotVInstall...then i'd figure if they moved the cursor
  458.     to another monitor, it'd work ok...and in the Stop function, do the
  459.     same thing but call SlotVRemove.  but again, this is all just my guess...
  460.     
  461.     and finally (i'm almost done, i hope), i hope that all my VBL code and
  462.     usage falls within the parameters of using a VBL task (these rules are
  463.     set forth in IM:Processes 4-6).  here's hoping...but heck, this code
  464.     is pretty much taken from Inside Macintosh..you'd think Apple wouldn't
  465.     write bad code, y'know?
  466.  
  467.     So, I guess the bottom line of it all is, pray what i have works (sure using
  468.     VInstall works, might flicker a bit on the redraws, but spinning a cursor
  469.     doesn't require graphics precision like a game might), send me money to
  470.     let me buy another monitor and a decent computer to use 2 monitors on! (just
  471.     kidding!), and YOU get a copy of IM:Processes and read up!
  472.     
  473.     Last thing:  i forgot just who helped me with this code!  the code as written
  474.     in IM:Processes did involve some assembly and wouldn't work on PowerMacs.
  475.     I posted on comp.sys.mac.programmer.help and 2 guys replied to me (the joys
  476.     of usenet news!).  but i forgot the guys's names and email addresses!  argh!
  477.     
  478.     well, one guy i know is named Skip...and i know i have their names around
  479.     here somewhere....when i find them, i'll be sure to include them!  the
  480.     biggest thing they helped me with was modifying the code to work with PowerMacs
  481.     and 68k Macs all from the same source.  one of them had the right idea 
  482.     (the #pragma parameter) stuff, but it wasn't quite right, so i just had to do
  483.     a little research and modification and viola!  thanx guys!
  484.     
  485.     Now, enough talk, let's code!
  486. */
  487.  
  488.  
  489. // interesting to note, we're not going to use our 'acur' resource.  we probably could,
  490. // but it's not worth the hassle
  491.  
  492. // a little global for easy data access
  493.  
  494. CursorTask gMyCursTask;
  495.  
  496. // and a global UPP for our callback
  497.  
  498. VBLUPP    gMyVBLUPP = nil;
  499.  
  500.  
  501. // HsoiChangeCursor is the nice little function the VRMgr actually calls to "animate"
  502. // the cursor.  This is what's installed into the VBLTask
  503.  
  504. /*
  505.     Ok...fun note...
  506.     
  507.     I originally did this a bit differently, using conditonal macros to get
  508.     different function signatures and prototypes.  Now in some places, this might
  509.     work ok, but here, it doesn't work.  Due to the nature of the VRMgr, 68k/PPC
  510.     chips, and the MacOS, we have to actually perform things a bit strangely to
  511.     get the same code to work on either chip.
  512.     
  513.     it worked fine on the 68k side of things...but when i tried it on a PowerMac,
  514.     it died everywhere....  I got a bomb saying "Math Coprocessor not installed"
  515.     and had to restart...
  516.     
  517.     now, this shouldn't even be an issue on the PowerMacs anyways, but oh well.
  518.     there's a tech note somewhere explaining this strange error, but i won't sweat
  519.     it now...
  520.     
  521.     point is, i took Skip's idea of using the #pragma parameter method.  his
  522.     code wasn't correct (it was off the top of his head), but that coupled with
  523.     some info i got from the CW8 C/C++/Assembly Language Ref (QuickView database,
  524.     just did a search through all the db's using "pragma" as the keyword) and found
  525.     the info i needed.  That gave me the proper syntax for this all.
  526.     
  527.     I have just tested it on a 68k and this method worked great!  and i tried it
  528.     on a PowerMac and it worked fine too.  So, a nice way to get VBL's working regardless
  529.     of the chip!
  530. */
  531.  
  532. // the little magic that makes it all work.... :)
  533.  
  534. #if !GENERATINGCFM
  535.     #pragma parameter HsoiChangeCursor( __A0 )
  536. #endif
  537.  
  538. // basically, if making a 68k app....
  539.  
  540. #if !GENERATINGCFM
  541. void HsoiChangeCursor( CursorTaskPtr recPtr );        // function prototype
  542.  
  543. void HsoiChangeCursor( CursorTaskPtr recPtr:__A0 )    // beginning of the actual function
  544. #else // PPC or CFM app
  545. void HsoiChangeCursor( CursorTaskPtr recPtr );        // function prototype
  546. void HsoiChangeCursor( CursorTaskPtr recPtr )        // beginning of actual function
  547. #endif
  548.  
  549. // note how the conditional preprocessor macros work above to give us the right
  550. // prototype and function name/arguments for this following stuff....
  551.  
  552. {
  553.     // if the cursor is busy, we should not change it
  554.     
  555.     if ( !LMGetCrsrBusy() )
  556.     {
  557.         // update the cursor information
  558.         
  559.         // display the next cursor
  560.         
  561.         SetCursor( *(recPtr->myCursors[ recPtr->myFrame ]) );
  562.         
  563.         // advance to the next cursor frame
  564.         
  565.         recPtr->myFrame += 1;
  566.         
  567.         // and wrap around to the first frame
  568.         
  569.         if ( recPtr->myFrame > (kNumberOfCursors - 1) )
  570.             recPtr->myFrame = 0;
  571.     }
  572.     
  573.     // and set the task to run again (at every interrupt, the VRMgr decrements this
  574.     // variable (vblCount) by one.  when vblCount hits zero, the task is executed once.
  575.     // to have the task executed again, we have to reset this variable back above zero
  576.     // for the VRMgr to decrement.  incidentally, if you didn't want to VRMgr to execute
  577.     // this task again, you could just set/leave vblCount at zero.  this is one way of
  578.     // disabling a VBL task, so say you had a VBL task that could run during a major/minor
  579.     // context switch (like suspend/resume), you could just set vblCount to 0 upon suspend
  580.     // and it won't execute, then reset it to kInterval upon resume)
  581.     
  582.     recPtr->myVBLTask.vblCount = kInterval;
  583.     
  584.     return;
  585. }
  586.  
  587.  
  588.  
  589.  
  590. // HsoiStartVBLSpinning is our "public" routine to start the whole process.  you call
  591. // this function from "wherever" (remember, there are limits/restrictions as to where you can
  592. // call this from) in your code that you want to start a spinning VBL cursor
  593.  
  594. void    HsoiStartVBLSpinning( void )
  595. {
  596.     OSErr        err;
  597.     short        count;
  598.  
  599.     // get our UPP set up
  600.     if ( gMyVBLUPP == nil )
  601.         gMyVBLUPP = NewVBLProc(HsoiChangeCursor);
  602.         
  603.     // initialize the cursor information
  604.     
  605.     for ( count = 0; count < kNumberOfCursors; count++ )
  606.     {
  607.         // load the cursor into memory
  608.         
  609.         gMyCursTask.myCursors[count] = GetCursor( kInitialResID + count );
  610.         
  611.         // lock the cursor so that we can call SetCursor at interrupt time
  612.         
  613.         HLockHi( (Handle)gMyCursTask.myCursors[count] );
  614.     }
  615.     
  616.     // display cursor with kInitialResID first
  617.     
  618.     gMyCursTask.myFrame = 0;
  619.     
  620.     // initialize the VBL task record
  621.     
  622.     gMyCursTask.myVBLTask.qType = vType;    // set the queue type
  623.     gMyCursTask.myVBLTask.vblAddr = gMyVBLUPP; // get address of VBL task
  624.     gMyCursTask.myVBLTask.vblCount = kInitialDelay; // set task frequency
  625.     // notice by setting the initial delay much larger than the number of interrupts
  626.     // between subsequent cursor changes, we prevent the cursor from starting to spin
  627.     // until a reasonable time (about 2 seconds) has elapsed.  adds a nice, cool
  628.     // cosmetic touch!
  629.     
  630.     gMyCursTask.myVBLTask.vblPhase = 0; // no phase
  631.     
  632.     // make sure our cursor isn't hidden
  633.     
  634.     ShowCursor();
  635.     
  636.     // install it
  637.     
  638.     err = VInstall( (QElemPtr) &(gMyCursTask.myVBLTask) );
  639.     
  640.     return;
  641. }
  642.  
  643. // and this goes along with HsoiStartVBLSpinning.  i'm sure you can guess what it does, but if
  644. // not, HsoiStopVBLSpinning stops the VBL spinning cursor from spinning.  It's probably safe
  645. // to say that any calls to HsoiStartVBLSpinning ought to be soon followed by a HsoiStopVBLSpinning
  646. // call (and there should be equal calls to these in your code, i.e. if you have 3 calls
  647. // to Start, there should be 3 calls to Stop...get why?)
  648.  
  649. void    HsoiStopVBLSpinning( void )
  650. {
  651.     OSErr        err;
  652.     short        count;
  653.     
  654.     // remove the task record from its queue
  655.     
  656.     err = VRemove( (QElemPtr) &(gMyCursTask.myVBLTask) );
  657.     
  658.     // free memory occupied by the cursors
  659.     
  660.     for ( count = 0; count < kNumberOfCursors; count++ )
  661.     {
  662.         HUnlock( (Handle)gMyCursTask.myCursors[count] );
  663.         HsoiForgetResource( (Handle *)&gMyCursTask.myCursors[count] );
  664.     }
  665.     
  666.     // or, if you didn't want to rely on HAS's ForgetResource function, just call this:
  667.     // ReleaseResource( (Handle)gMyCursTask.myCursors[count] );
  668.  
  669.     // dispose our routine descriptor
  670.     
  671.     DisposeRoutineDescriptor( gMyVBLUPP );
  672.     gMyVBLUPP = nil; // make sure the handle is nilled out so we "can't" use it accidentally
  673.  
  674.     // and set the cursor up nicely
  675.     
  676.     InitCursor();
  677.     
  678.     return;
  679. }